#include "ByteArray.h"




//====================================================================
//
//
//====================================================================
ByteArray::ByteArray()
:	m_data(NULL),
	m_dataLen(0),
	m_dataPointer(0)
{

}

//====================================================================
//
//
//====================================================================
ByteArray::~ByteArray()
{
	clear();
}

//====================================================================
//
//
//====================================================================
void ByteArray::seek(unsigned int pos)
{
	if(pos < m_dataLen)
	{
		m_dataPointer = pos;
	}
}

//====================================================================
//
//
//====================================================================
void ByteArray::seekBegin()
{
	m_dataPointer = 0;
}

//====================================================================
//
//
//====================================================================
void ByteArray::seekEnd()
{
	m_dataPointer = m_dataLen;
}

//====================================================================
//
//
//====================================================================
unsigned int ByteArray::position()
{
	return m_dataPointer;
}

//====================================================================
//
//
//====================================================================
unsigned int ByteArray::length()
{
	return m_dataLen;
}

//====================================================================
//
//
//====================================================================
void ByteArray::clear()
{
	if(m_data != NULL)
	{
		delete[] m_data;
		m_data = NULL;
	}
	m_dataLen = 0;
	m_dataPointer = 0;
}

//====================================================================
//
//
//====================================================================
int ByteArray::readInt()
{
	if(m_dataLen - m_dataPointer >= sizeof(int))
	{
		int res;
		memcpy(&res, m_data + m_dataPointer, sizeof(int));
		m_dataPointer += sizeof(int);
		return res;
	}

	return 0;
}

//====================================================================
//
//
//====================================================================
double ByteArray::readDouble()
{
	if(m_dataLen - m_dataPointer >= sizeof(double))
	{
		double res;
		memcpy(&res, m_data + m_dataPointer, sizeof(double));
		m_dataPointer += sizeof(double);
		return res;
	}

	return 0;
}

//====================================================================
//
//
//====================================================================
char* ByteArray::readBytes()
{
	return m_data;
}

//====================================================================
//
//
//====================================================================
std::string ByteArray::readUTF()
{
	unsigned short len;
	if(m_dataLen - m_dataPointer >= sizeof(len))
	{
		memcpy(&len, m_data + m_dataPointer, sizeof(len));
		m_dataPointer += sizeof(len);
	}

	std::string res = "";
	if(m_dataLen - m_dataPointer >= len)
	{
		char* buff = new char[len + 1];
		memcpy(buff, m_data + m_dataPointer, len);
		buff[len] = '\0';
		res = std::string(buff);
		m_dataPointer += len;
	}

	return res;
}

//====================================================================
//
//
//====================================================================
void ByteArray::checkAndResize(unsigned int len)
{
	if(m_dataLen - m_dataPointer < len)
	{
		if(m_dataLen > 0)
		{
			char* buff = new char[m_dataLen + len];
			memcpy(buff, m_data, m_dataLen);
			delete[] m_data;
			m_data = buff;
		}
		else
		{
			m_data = new char[len];
		}
	}
}

//====================================================================
//
//
//====================================================================
void ByteArray::writeBytes(char *bytes, unsigned int len)
{
	checkAndResize(len);

	memcpy(m_data + m_dataPointer, bytes, len);

	m_dataPointer += len;
	m_dataLen += len;
}

//====================================================================
//
//
//====================================================================
void ByteArray::writeUTF(std::string str)
{
	short len = str.size();

	checkAndResize(len + sizeof(len));

	memcpy(m_data + m_dataPointer, (char*)&len, sizeof(len));
	m_dataPointer += sizeof(len);
	m_dataLen += sizeof(len);
	memcpy(m_data + m_dataPointer, str.c_str(), len);

	m_dataPointer += len;
	m_dataLen += len;
}

//====================================================================
//
//
//====================================================================
void ByteArray::writeInt(int value)
{
	int len = sizeof(int);
	checkAndResize(len);

	//int swap = Utils::swapBytes(value);

	memcpy(m_data + m_dataPointer, (char*)&value, len);

	m_dataPointer += len;
	m_dataLen += len;
}

//====================================================================
//
//
//====================================================================
void ByteArray::writeDouble(double value)
{
	int len = sizeof(value);
	checkAndResize(len);

	//int swap = Utils::swapBytes(value);

	memcpy(m_data + m_dataPointer, (char*)&value, len);

	m_dataPointer += len;
	m_dataLen += len;
}